/*-------------------------------------------------------------------------
 *
 * alter.c
 *	  通用修改命令的驱动程序
 *
 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, 加利福尼亚大学董事会
 *
 *
 * IDENTIFICATION
 *	  src/backend/commands/alter.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "access/htup_details.h"
#include "access/relation.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_foreign_data_wrapper.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_largeobject.h"
#include "catalog/pg_largeobject_metadata.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "commands/alter.h"
#include "commands/collationcmds.h"
#include "commands/conversioncmds.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "commands/extension.h"
#include "commands/policy.h"
#include "commands/proclang.h"
#include "commands/publicationcmds.h"
#include "commands/schemacmds.h"
#include "commands/subscriptioncmds.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "commands/typecmds.h"
#include "commands/user.h"
#include "miscadmin.h"
#include "parser/parse_func.h"
#include "rewrite/rewriteDefine.h"
#include "storage/lmgr.h"
#include "tcop/utility.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

static Oid	fc_AlterObjectNamespace_internal(Relation fc_rel, Oid fc_objid, Oid fc_nspOid);

/*
 * 引发一个错误，表示给定名称的对象已经存在于给定的命名空间中。
 */
static void fc_report_name_conflict(Oid fc_classId, const char *fc_name)
{
	char	   *fc_msgfmt;

	switch (fc_classId)
	{
		case EventTriggerRelationId:
			fc_msgfmt = gettext_noop("event trigger \"%s\" already exists");
			break;
		case ForeignDataWrapperRelationId:
			fc_msgfmt = gettext_noop("foreign-data wrapper \"%s\" already exists");
			break;
		case ForeignServerRelationId:
			fc_msgfmt = gettext_noop("server \"%s\" already exists");
			break;
		case LanguageRelationId:
			fc_msgfmt = gettext_noop("language \"%s\" already exists");
			break;
		case PublicationRelationId:
			fc_msgfmt = gettext_noop("publication \"%s\" already exists");
			break;
		case SubscriptionRelationId:
			fc_msgfmt = gettext_noop("subscription \"%s\" already exists");
			break;
		default:
			elog(ERROR, "unsupported object class %u", fc_classId);
			break;
	}

	ereport(ERROR,
			(errcode(ERRCODE_DUPLICATE_OBJECT),
			 errmsg(fc_msgfmt, fc_name)));
}

static void fc_report_namespace_conflict(Oid fc_classId, const char *fc_name, Oid fc_nspOid)
{
	char	   *fc_msgfmt;

	Assert(OidIsValid(fc_nspOid));

	switch (fc_classId)
	{
		case ConversionRelationId:
			Assert(OidIsValid(fc_nspOid));
			fc_msgfmt = gettext_noop("conversion \"%s\" already exists in schema \"%s\"");
			break;
		case StatisticExtRelationId:
			Assert(OidIsValid(fc_nspOid));
			fc_msgfmt = gettext_noop("statistics object \"%s\" already exists in schema \"%s\"");
			break;
		case TSParserRelationId:
			Assert(OidIsValid(fc_nspOid));
			fc_msgfmt = gettext_noop("text search parser \"%s\" already exists in schema \"%s\"");
			break;
		case TSDictionaryRelationId:
			Assert(OidIsValid(fc_nspOid));
			fc_msgfmt = gettext_noop("text search dictionary \"%s\" already exists in schema \"%s\"");
			break;
		case TSTemplateRelationId:
			Assert(OidIsValid(fc_nspOid));
			fc_msgfmt = gettext_noop("text search template \"%s\" already exists in schema \"%s\"");
			break;
		case TSConfigRelationId:
			Assert(OidIsValid(fc_nspOid));
			fc_msgfmt = gettext_noop("text search configuration \"%s\" already exists in schema \"%s\"");
			break;
		default:
			elog(ERROR, "unsupported object class %u", fc_classId);
			break;
	}

	ereport(ERROR,
			(errcode(ERRCODE_DUPLICATE_OBJECT),
			 errmsg(fc_msgfmt, fc_name, get_namespace_name(fc_nspOid))));
}

/*
 * AlterObjectRename_internal
 *
 * 一般函数用于重命名给定对象，适用于简单情况（无法对表或其他需要做更多操作的情况进行处理，超出单个目录条目的名称列更改）。
 *
 * rel: 包含对象的目录关系（由调用者持有行级独占锁）
 * objectId: 要重命名的对象的OID
 * new_name: 新名称的CString表示
 */
static void fc_AlterObjectRename_internal(Relation fc_rel, Oid fc_objectId, const char *fc_new_name)
{
	Oid			fc_classId = RelationGetRelid(fc_rel);
	int			fc_oidCacheId = get_object_catcache_oid(fc_classId);
	int			fc_nameCacheId = get_object_catcache_name(fc_classId);
	AttrNumber	fc_Anum_name = get_object_attnum_name(fc_classId);
	AttrNumber	fc_Anum_namespace = get_object_attnum_namespace(fc_classId);
	AttrNumber	fc_Anum_owner = get_object_attnum_owner(fc_classId);
	HeapTuple	fc_oldtup;
	HeapTuple	fc_newtup;
	Datum		fc_datum;
	bool		fc_isnull;
	Oid			fc_namespaceId;
	Oid			fc_ownerId;
	char	   *fc_old_name;
	AclResult	fc_aclresult;
	Datum	   *fc_values;
	bool	   *fc_nulls;
	bool	   *fc_replaces;
	NameData	fc_nameattrdata;

	fc_oldtup = SearchSysCache1(fc_oidCacheId, ObjectIdGetDatum(fc_objectId));
	if (!HeapTupleIsValid(fc_oldtup))
		elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
			 fc_objectId, RelationGetRelationName(fc_rel));

	fc_datum = heap_getattr(fc_oldtup, fc_Anum_name,
						 RelationGetDescr(fc_rel), &fc_isnull);
	Assert(!fc_isnull);
	fc_old_name = NameStr(*(DatumGetName(fc_datum)));

	/* 获取命名空间的OID */
	if (fc_Anum_namespace > 0)
	{
		fc_datum = heap_getattr(fc_oldtup, fc_Anum_namespace,
							 RelationGetDescr(fc_rel), &fc_isnull);
		Assert(!fc_isnull);
		fc_namespaceId = DatumGetObjectId(fc_datum);
	}
	else
		fc_namespaceId = InvalidOid;

	/* 权限检查... 超级用户始终可以执行此操作 */
	if (!superuser())
	{
		/* 如果对象没有明确的所有者，则失败 */
		if (fc_Anum_owner <= 0)
			ereport(ERROR,
					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
					 errmsg("must be superuser to rename %s",
							getObjectDescriptionOids(fc_classId, fc_objectId))));

		/* 否则，必须是现有对象的所有者 */
		fc_datum = heap_getattr(fc_oldtup, fc_Anum_owner,
							 RelationGetDescr(fc_rel), &fc_isnull);
		Assert(!fc_isnull);
		fc_ownerId = DatumGetObjectId(fc_datum);

		if (!has_privs_of_role(GetUserId(), DatumGetObjectId(fc_ownerId)))
			aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(fc_classId, fc_objectId),
						   fc_old_name);

		/* 用户必须具有命名空间上的CREATE权限 */
		if (OidIsValid(fc_namespaceId))
		{
			fc_aclresult = pg_namespace_aclcheck(fc_namespaceId, GetUserId(),
											  ACL_CREATE);
			if (fc_aclresult != ACLCHECK_OK)
				aclcheck_error(fc_aclresult, OBJECT_SCHEMA,
							   get_namespace_name(fc_namespaceId));
		}
	}

	/*
	 * 检查重复名称（比唯一索引失败更友好）。
	 * 由于这只是一个友好性检查，适当支持的情况下可以跳过。
	 */
	if (fc_classId == ProcedureRelationId)
	{
		Form_pg_proc fc_proc = (Form_pg_proc) GETSTRUCT(fc_oldtup);

		IsThereFunctionInNamespace(fc_new_name, fc_proc->pronargs,
								   &fc_proc->proargtypes, fc_proc->pronamespace);
	}
	else if (fc_classId == CollationRelationId)
	{
		Form_pg_collation fc_coll = (Form_pg_collation) GETSTRUCT(fc_oldtup);

		IsThereCollationInNamespace(fc_new_name, fc_coll->collnamespace);
	}
	else if (fc_classId == OperatorClassRelationId)
	{
		Form_pg_opclass fc_opc = (Form_pg_opclass) GETSTRUCT(fc_oldtup);

		IsThereOpClassInNamespace(fc_new_name, fc_opc->opcmethod,
								  fc_opc->opcnamespace);
	}
	else if (fc_classId == OperatorFamilyRelationId)
	{
		Form_pg_opfamily fc_opf = (Form_pg_opfamily) GETSTRUCT(fc_oldtup);

		IsThereOpFamilyInNamespace(fc_new_name, fc_opf->opfmethod,
								   fc_opf->opfnamespace);
	}
	else if (fc_classId == SubscriptionRelationId)
	{
		if (SearchSysCacheExists2(SUBSCRIPTIONNAME, MyDatabaseId,
								  CStringGetDatum(fc_new_name)))
			fc_report_name_conflict(fc_classId, fc_new_name);

		/* 如果启用，也执行回归测试命名规则 */
#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
		if (strncmp(fc_new_name, "regress_", 8) != 0)
			elog(WARNING, "subscriptions created by regression test cases should have names starting with \"regress_\"");
#endif
	}
	else if (fc_nameCacheId >= 0)
	{
		if (OidIsValid(fc_namespaceId))
		{
			if (SearchSysCacheExists2(fc_nameCacheId,
									  CStringGetDatum(fc_new_name),
									  ObjectIdGetDatum(fc_namespaceId)))
				fc_report_namespace_conflict(fc_classId, fc_new_name, fc_namespaceId);
		}
		else
		{
			if (SearchSysCacheExists1(fc_nameCacheId,
									  CStringGetDatum(fc_new_name)))
				fc_report_name_conflict(fc_classId, fc_new_name);
		}
	}

	/* 构建修改后的元组 */
	fc_values = palloc0(RelationGetNumberOfAttributes(fc_rel) * sizeof(Datum));
	fc_nulls = palloc0(RelationGetNumberOfAttributes(fc_rel) * sizeof(bool));
	fc_replaces = palloc0(RelationGetNumberOfAttributes(fc_rel) * sizeof(bool));
	namestrcpy(&fc_nameattrdata, fc_new_name);
	fc_values[fc_Anum_name - 1] = NameGetDatum(&fc_nameattrdata);
	fc_replaces[fc_Anum_name - 1] = true;
	fc_newtup = heap_modify_tuple(fc_oldtup, RelationGetDescr(fc_rel),
							   fc_values, fc_nulls, fc_replaces);

	/* 执行实际更新 */
	CatalogTupleUpdate(fc_rel, &fc_oldtup->t_self, fc_newtup);

	InvokeObjectPostAlterHook(fc_classId, fc_objectId, 0);

	/* 释放内存 */
	pfree(fc_values);
	pfree(fc_nulls);
	pfree(fc_replaces);
	heap_freetuple(fc_newtup);

	ReleaseSysCache(fc_oldtup);
}

/*
 * 执行ALTER OBJECT / RENAME TO语句。根据对象类型，执行适合该类型的函数。
 *
 * 返回值是重命名对象的地址。
 */
ObjectAddress ExecRenameStmt(RenameStmt *fc_stmt)
{
	switch (fc_stmt->renameType)
	{
		case OBJECT_TABCONSTRAINT:
		case OBJECT_DOMCONSTRAINT:
			return RenameConstraint(fc_stmt);

		case OBJECT_DATABASE:
			return RenameDatabase(fc_stmt->subname, fc_stmt->newname);

		case OBJECT_ROLE:
			return RenameRole(fc_stmt->subname, fc_stmt->newname);

		case OBJECT_SCHEMA:
			return RenameSchema(fc_stmt->subname, fc_stmt->newname);

		case OBJECT_TABLESPACE:
			return RenameTableSpace(fc_stmt->subname, fc_stmt->newname);

		case OBJECT_TABLE:
		case OBJECT_SEQUENCE:
		case OBJECT_VIEW:
		case OBJECT_MATVIEW:
		case OBJECT_INDEX:
		case OBJECT_FOREIGN_TABLE:
			return RenameRelation(fc_stmt);

		case OBJECT_COLUMN:
		case OBJECT_ATTRIBUTE:
			return renameatt(fc_stmt);

		case OBJECT_RULE:
			return RenameRewriteRule(fc_stmt->relation, fc_stmt->subname,
									 fc_stmt->newname);

		case OBJECT_TRIGGER:
			return renametrig(fc_stmt);

		case OBJECT_POLICY:
			return rename_policy(fc_stmt);

		case OBJECT_DOMAIN:
		case OBJECT_TYPE:
			return RenameType(fc_stmt);

		case OBJECT_AGGREGATE:
		case OBJECT_COLLATION:
		case OBJECT_CONVERSION:
		case OBJECT_EVENT_TRIGGER:
		case OBJECT_FDW:
		case OBJECT_FOREIGN_SERVER:
		case OBJECT_FUNCTION:
		case OBJECT_OPCLASS:
		case OBJECT_OPFAMILY:
		case OBJECT_LANGUAGE:
		case OBJECT_PROCEDURE:
		case OBJECT_ROUTINE:
		case OBJECT_STATISTIC_EXT:
		case OBJECT_TSCONFIGURATION:
		case OBJECT_TSDICTIONARY:
		case OBJECT_TSPARSER:
		case OBJECT_TSTEMPLATE:
		case OBJECT_PUBLICATION:
		case OBJECT_SUBSCRIPTION:
			{
				ObjectAddress fc_address;
				Relation	fc_catalog;
				Relation	fc_relation;

				fc_address = get_object_address(fc_stmt->renameType,
											 fc_stmt->object,
											 &fc_relation,
											 AccessExclusiveLock, false);
				Assert(fc_relation == NULL);

				fc_catalog = table_open(fc_address.classId, RowExclusiveLock);
				fc_AlterObjectRename_internal(fc_catalog,
										   fc_address.objectId,
										   fc_stmt->newname);
				table_close(fc_catalog, RowExclusiveLock);

				return fc_address;
			}

		default:
			elog(ERROR, "unrecognized rename stmt type: %d",
				 (int) fc_stmt->renameType);
			return InvalidObjectAddress;	/* 保持编译器开心 */
	}
}

/*
 * 执行ALTER OBJECT / [NO] DEPENDS ON EXTENSION语句。
 *
 * 返回值是被更改对象的地址。refAddress是一个输出参数，如果不为null，将接收被更改对象现在依赖的对象的地址。
 */
ObjectAddress ExecAlterObjectDependsStmt(AlterObjectDependsStmt *fc_stmt, ObjectAddress *fc_refAddress)
{
	ObjectAddress fc_address;
	ObjectAddress fc_refAddr;
	Relation	fc_rel;

	fc_address =
		get_object_address_rv(fc_stmt->objectType, fc_stmt->relation, (List *) fc_stmt->object,
							  &fc_rel, AccessExclusiveLock, false);

	/*
	 * 验证用户是否有权运行该命令。
	 *
	 * 我们不检查扩展上的任何权限，因为这不是必需的。对象所有者通过运行此命令，表明扩展所有者可以在他们觉得合适的时候删除该对象，这被认为不是问题。
	 */
	check_object_ownership(GetUserId(),
						   fc_stmt->objectType, fc_address, fc_stmt->object, fc_rel);

	/*
	 * 如果涉及关系，它将被打开并锁定。我们不需要这里的关系，但在提交之前会保持锁定。
	 */
	if (fc_rel)
		table_close(fc_rel, NoLock);

	fc_refAddr = get_object_address(OBJECT_EXTENSION, (Node *) fc_stmt->extname,
								 &fc_rel, AccessExclusiveLock, false);
	Assert(fc_rel == NULL);
	if (fc_refAddress)
		*fc_refAddress = fc_refAddr;

	if (fc_stmt->remove)
	{
		deleteDependencyRecordsForSpecific(fc_address.classId, fc_address.objectId,
										   DEPENDENCY_AUTO_EXTENSION,
										   fc_refAddr.classId, fc_refAddr.objectId);
	}
	else
	{
		List	   *fc_currexts;

		/* 避免重复 */
		fc_currexts = getAutoExtensionsOfObject(fc_address.classId,
											 fc_address.objectId);
		if (!list_member_oid(fc_currexts, fc_refAddr.objectId))
			recordDependencyOn(&fc_address, &fc_refAddr, DEPENDENCY_AUTO_EXTENSION);
	}

	return fc_address;
}

/*
 * 执行ALTER OBJECT / SET SCHEMA语句。根据对象类型，执行适合该类型的函数。
 *
 * 返回值是被更改对象的值。
 *
 * oldSchemaAddr是一个输出参数，如果不为NULL，则设置为原始架构的对象地址。
 */
ObjectAddress ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *fc_stmt,
						  ObjectAddress *fc_oldSchemaAddr)
{
	ObjectAddress fc_address;
	Oid			fc_oldNspOid;

	switch (fc_stmt->objectType)
	{
		case OBJECT_EXTENSION:
			fc_address = AlterExtensionNamespace(strVal(fc_stmt->object), fc_stmt->newschema,
											  fc_oldSchemaAddr ? &fc_oldNspOid : NULL);
			break;

		case OBJECT_FOREIGN_TABLE:
		case OBJECT_SEQUENCE:
		case OBJECT_TABLE:
		case OBJECT_VIEW:
		case OBJECT_MATVIEW:
			fc_address = AlterTableNamespace(fc_stmt,
										  fc_oldSchemaAddr ? &fc_oldNspOid : NULL);
			break;

		case OBJECT_DOMAIN:
		case OBJECT_TYPE:
			fc_address = AlterTypeNamespace(castNode(List, fc_stmt->object), fc_stmt->newschema,
										 fc_stmt->objectType,
										 fc_oldSchemaAddr ? &fc_oldNspOid : NULL);
			break;

			/* 通用代码路径 */
		case OBJECT_AGGREGATE:
		case OBJECT_COLLATION:
		case OBJECT_CONVERSION:
		case OBJECT_FUNCTION:
		case OBJECT_OPERATOR:
		case OBJECT_OPCLASS:
		case OBJECT_OPFAMILY:
		case OBJECT_PROCEDURE:
		case OBJECT_ROUTINE:
		case OBJECT_STATISTIC_EXT:
		case OBJECT_TSCONFIGURATION:
		case OBJECT_TSDICTIONARY:
		case OBJECT_TSPARSER:
		case OBJECT_TSTEMPLATE:
			{
				Relation	fc_catalog;
				Relation	fc_relation;
				Oid			fc_classId;
				Oid			fc_nspOid;

				fc_address = get_object_address(fc_stmt->objectType,
											 fc_stmt->object,
											 &fc_relation,
											 AccessExclusiveLock,
											 false);
				Assert(fc_relation == NULL);
				fc_classId = fc_address.classId;
				fc_catalog = table_open(fc_classId, RowExclusiveLock);
				fc_nspOid = LookupCreationNamespace(fc_stmt->newschema);

				fc_oldNspOid = fc_AlterObjectNamespace_internal(fc_catalog, fc_address.objectId,
														  fc_nspOid);
				table_close(fc_catalog, RowExclusiveLock);
			}
			break;

		default:
			elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
				 (int) fc_stmt->objectType);
			return InvalidObjectAddress;	/* 保持编译器开心 */
	}

	if (fc_oldSchemaAddr)
		ObjectAddressSet(*fc_oldSchemaAddr, NamespaceRelationId, fc_oldNspOid);

	return fc_address;
}

/*
 * 根据其 classOid 和 object Oid 更改对象的命名空间。
 *
 * 没有命名空间的对象应被忽略。
 *
 * 此函数目前仅由 ALTER EXTENSION SET SCHEMA 使用，
 * 因此只需要涵盖可以作为扩展成员的对象类型，
 * 并且不必处理某些特殊情况
 * 例如不想处理数组类型——这些类型通常不应直接
 * 是扩展的成员。 但是，我们坚持在 switch 中列出所有 OCLASS 类型。
 *
 * 返回对象之前命名空间的 OID，如果对象没有架构则返回 InvalidOid。
 */
Oid AlterObjectNamespace_oid(Oid fc_classId, Oid fc_objid, Oid fc_nspOid,
						 ObjectAddresses *fc_objsMoved)
{
	Oid			fc_oldNspOid = InvalidOid;
	ObjectAddress fc_dep;

	fc_dep.classId = fc_classId;
	fc_dep.objectId = fc_objid;
	fc_dep.objectSubId = 0;

	switch (getObjectClass(&fc_dep))
	{
		case OCLASS_CLASS:
			{
				Relation	fc_rel;

				fc_rel = relation_open(fc_objid, AccessExclusiveLock);
				fc_oldNspOid = RelationGetNamespace(fc_rel);

				AlterTableNamespaceInternal(fc_rel, fc_oldNspOid, fc_nspOid, fc_objsMoved);

				relation_close(fc_rel, NoLock);
				break;
			}

		case OCLASS_TYPE:
			fc_oldNspOid = AlterTypeNamespace_oid(fc_objid, fc_nspOid, fc_objsMoved);
			break;

		case OCLASS_PROC:
		case OCLASS_COLLATION:
		case OCLASS_CONVERSION:
		case OCLASS_OPERATOR:
		case OCLASS_OPCLASS:
		case OCLASS_OPFAMILY:
		case OCLASS_STATISTIC_EXT:
		case OCLASS_TSPARSER:
		case OCLASS_TSDICT:
		case OCLASS_TSTEMPLATE:
		case OCLASS_TSCONFIG:
			{
				Relation	fc_catalog;

				fc_catalog = table_open(fc_classId, RowExclusiveLock);

				fc_oldNspOid = fc_AlterObjectNamespace_internal(fc_catalog, fc_objid,
														  fc_nspOid);

				table_close(fc_catalog, RowExclusiveLock);
			}
			break;

		case OCLASS_CAST:
		case OCLASS_CONSTRAINT:
		case OCLASS_DEFAULT:
		case OCLASS_LANGUAGE:
		case OCLASS_LARGEOBJECT:
		case OCLASS_AM:
		case OCLASS_AMOP:
		case OCLASS_AMPROC:
		case OCLASS_REWRITE:
		case OCLASS_TRIGGER:
		case OCLASS_SCHEMA:
		case OCLASS_ROLE:
		case OCLASS_DATABASE:
		case OCLASS_TBLSPACE:
		case OCLASS_FDW:
		case OCLASS_FOREIGN_SERVER:
		case OCLASS_USER_MAPPING:
		case OCLASS_DEFACL:
		case OCLASS_EXTENSION:
		case OCLASS_EVENT_TRIGGER:
		case OCLASS_PARAMETER_ACL:
		case OCLASS_POLICY:
		case OCLASS_PUBLICATION:
		case OCLASS_PUBLICATION_NAMESPACE:
		case OCLASS_PUBLICATION_REL:
		case OCLASS_SUBSCRIPTION:
		case OCLASS_TRANSFORM:
			/* 忽略没有架构限定名称的对象类型 */
			break;

			/*
			 * 这里故意没有默认 case；我们希望编译器
			 * 在上面未处理新 OCLASS 时发出警告。
			 */
	}

	return fc_oldNspOid;
}

/*
 * 通用函数，用于更改给定对象的命名空间，适用于简单
 * 情况（对表和其他需要做的不仅仅是更改单个目录条目
 * 的命名空间列的情况无效）。
 *
 * rel: 包含对象的目录关系（由调用者 RowExclusiveLock）
 * objid: 要更改命名空间的对象的 OID
 * nspOid: 新命名空间的 OID
 *
 * 返回对象之前命名空间的 OID。
 */
static Oid fc_AlterObjectNamespace_internal(Relation fc_rel, Oid fc_objid, Oid fc_nspOid)
{
	Oid			fc_classId = RelationGetRelid(fc_rel);
	int			fc_oidCacheId = get_object_catcache_oid(fc_classId);
	int			fc_nameCacheId = get_object_catcache_name(fc_classId);
	AttrNumber	fc_Anum_name = get_object_attnum_name(fc_classId);
	AttrNumber	fc_Anum_namespace = get_object_attnum_namespace(fc_classId);
	AttrNumber	fc_Anum_owner = get_object_attnum_owner(fc_classId);
	Oid			fc_oldNspOid;
	Datum		fc_name,
				fc_namespace;
	bool		fc_isnull;
	HeapTuple	fc_tup,
				fc_newtup;
	Datum	   *fc_values;
	bool	   *fc_nulls;
	bool	   *fc_replaces;

	fc_tup = SearchSysCacheCopy1(fc_oidCacheId, ObjectIdGetDatum(fc_objid));
	if (!HeapTupleIsValid(fc_tup)) /* 不应该发生 */
		elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
			 fc_objid, RelationGetRelationName(fc_rel));

	fc_name = heap_getattr(fc_tup, fc_Anum_name, RelationGetDescr(fc_rel), &fc_isnull);
	Assert(!fc_isnull);
	fc_namespace = heap_getattr(fc_tup, fc_Anum_namespace, RelationGetDescr(fc_rel),
							 &fc_isnull);
	Assert(!fc_isnull);
	fc_oldNspOid = DatumGetObjectId(fc_namespace);

	/*
	 * 如果对象已经在正确的命名空间中，我们不需要做
	 * 任何事情，只需触发对象访问钩子。
	 */
	if (fc_oldNspOid == fc_nspOid)
	{
		InvokeObjectPostAlterHook(fc_classId, fc_objid, 0);
		return fc_oldNspOid;
	}

	/* 检查基本命名空间相关问题 */
	CheckSetNamespace(fc_oldNspOid, fc_nspOid);

	/* 权限检查... 超级用户始终可以执行此操作 */
	if (!superuser())
	{
		Datum		fc_owner;
		Oid			fc_ownerId;
		AclResult	fc_aclresult;

		/* 如果对象没有明确的所有者，则失败 */
		if (fc_Anum_owner <= 0)
			ereport(ERROR,
					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
					 errmsg("must be superuser to set schema of %s",
							getObjectDescriptionOids(fc_classId, fc_objid))));

		/* 否则，必须是现有对象的所有者 */
		fc_owner = heap_getattr(fc_tup, fc_Anum_owner, RelationGetDescr(fc_rel), &fc_isnull);
		Assert(!fc_isnull);
		fc_ownerId = DatumGetObjectId(fc_owner);

		if (!has_privs_of_role(GetUserId(), fc_ownerId))
			aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(fc_classId, fc_objid),
						   NameStr(*(DatumGetName(fc_name))));

		/* 用户必须对新命名空间拥有 CREATE 权限 */
		fc_aclresult = pg_namespace_aclcheck(fc_nspOid, GetUserId(), ACL_CREATE);
		if (fc_aclresult != ACLCHECK_OK)
			aclcheck_error(fc_aclresult, OBJECT_SCHEMA,
						   get_namespace_name(fc_nspOid));
	}

	/*
	 * 检查重复名称（比唯一索引失败更友好）。
	 * 由于这只是一个友好性检查，适当支持的情况下可以跳过。
	 */
	if (fc_classId == ProcedureRelationId)
	{
		Form_pg_proc fc_proc = (Form_pg_proc) GETSTRUCT(fc_tup);

		IsThereFunctionInNamespace(NameStr(fc_proc->proname), fc_proc->pronargs,
								   &fc_proc->proargtypes, fc_nspOid);
	}
	else if (fc_classId == CollationRelationId)
	{
		Form_pg_collation fc_coll = (Form_pg_collation) GETSTRUCT(fc_tup);

		IsThereCollationInNamespace(NameStr(fc_coll->collname), fc_nspOid);
	}
	else if (fc_classId == OperatorClassRelationId)
	{
		Form_pg_opclass fc_opc = (Form_pg_opclass) GETSTRUCT(fc_tup);

		IsThereOpClassInNamespace(NameStr(fc_opc->opcname),
								  fc_opc->opcmethod, fc_nspOid);
	}
	else if (fc_classId == OperatorFamilyRelationId)
	{
		Form_pg_opfamily fc_opf = (Form_pg_opfamily) GETSTRUCT(fc_tup);

		IsThereOpFamilyInNamespace(NameStr(fc_opf->opfname),
								   fc_opf->opfmethod, fc_nspOid);
	}
	else if (fc_nameCacheId >= 0 &&
			 SearchSysCacheExists2(fc_nameCacheId, fc_name,
								   ObjectIdGetDatum(fc_nspOid)))
		fc_report_namespace_conflict(fc_classId,
								  NameStr(*(DatumGetName(fc_name))),
								  fc_nspOid);

	/* 构建修改后的元组 */
	fc_values = palloc0(RelationGetNumberOfAttributes(fc_rel) * sizeof(Datum));
	fc_nulls = palloc0(RelationGetNumberOfAttributes(fc_rel) * sizeof(bool));
	fc_replaces = palloc0(RelationGetNumberOfAttributes(fc_rel) * sizeof(bool));
	fc_values[fc_Anum_namespace - 1] = ObjectIdGetDatum(fc_nspOid);
	fc_replaces[fc_Anum_namespace - 1] = true;
	fc_newtup = heap_modify_tuple(fc_tup, RelationGetDescr(fc_rel),
							   fc_values, fc_nulls, fc_replaces);

	/* 执行实际更新 */
	CatalogTupleUpdate(fc_rel, &fc_tup->t_self, fc_newtup);

	/* 释放内存 */
	pfree(fc_values);
	pfree(fc_nulls);
	pfree(fc_replaces);

	/* 更新依赖项以指向新架构 */
	changeDependencyFor(fc_classId, fc_objid,
						NamespaceRelationId, fc_oldNspOid, fc_nspOid);

	InvokeObjectPostAlterHook(fc_classId, fc_objid, 0);

	return fc_oldNspOid;
}

/*
 * 执行 ALTER OBJECT / OWNER TO 语句。根据对象
 * 类型，执行适合该类型的函数。
 */
ObjectAddress ExecAlterOwnerStmt(AlterOwnerStmt *fc_stmt)
{
	Oid			fc_newowner = get_rolespec_oid(fc_stmt->newowner, false);

	switch (fc_stmt->objectType)
	{
		case OBJECT_DATABASE:
			return AlterDatabaseOwner(strVal(fc_stmt->object), fc_newowner);

		case OBJECT_SCHEMA:
			return AlterSchemaOwner(strVal(fc_stmt->object), fc_newowner);

		case OBJECT_TYPE:
		case OBJECT_DOMAIN:		/* 与 TYPE 相同 */
			return AlterTypeOwner(castNode(List, fc_stmt->object), fc_newowner, fc_stmt->objectType);
			break;

		case OBJECT_FDW:
			return AlterForeignDataWrapperOwner(strVal(fc_stmt->object),
												fc_newowner);

		case OBJECT_FOREIGN_SERVER:
			return AlterForeignServerOwner(strVal(fc_stmt->object),
										   fc_newowner);

		case OBJECT_EVENT_TRIGGER:
			return AlterEventTriggerOwner(strVal(fc_stmt->object),
										  fc_newowner);

		case OBJECT_PUBLICATION:
			return AlterPublicationOwner(strVal(fc_stmt->object),
										 fc_newowner);

		case OBJECT_SUBSCRIPTION:
			return AlterSubscriptionOwner(strVal(fc_stmt->object),
										  fc_newowner);

			/* 通用情况 */
		case OBJECT_AGGREGATE:
		case OBJECT_COLLATION:
		case OBJECT_CONVERSION:
		case OBJECT_FUNCTION:
		case OBJECT_LANGUAGE:
		case OBJECT_LARGEOBJECT:
		case OBJECT_OPERATOR:
		case OBJECT_OPCLASS:
		case OBJECT_OPFAMILY:
		case OBJECT_PROCEDURE:
		case OBJECT_ROUTINE:
		case OBJECT_STATISTIC_EXT:
		case OBJECT_TABLESPACE:
		case OBJECT_TSDICTIONARY:
		case OBJECT_TSCONFIGURATION:
			{
				Relation	fc_catalog;
				Relation	fc_relation;
				Oid			fc_classId;
				ObjectAddress fc_address;

				fc_address = get_object_address(fc_stmt->objectType,
											 fc_stmt->object,
											 &fc_relation,
											 AccessExclusiveLock,
											 false);
				Assert(fc_relation == NULL);
				fc_classId = fc_address.classId;

				/*
				 * XXX - get_object_address 返回 OBJECT_LARGEOBJECT 的 pg_largeobject 
				 * 目录的 Oid 是出于历史原因。 在此修复它。
				 */
				if (fc_classId == LargeObjectRelationId)
					fc_classId = LargeObjectMetadataRelationId;

				fc_catalog = table_open(fc_classId, RowExclusiveLock);

				AlterObjectOwner_internal(fc_catalog, fc_address.objectId, fc_newowner);
				table_close(fc_catalog, RowExclusiveLock);

				return fc_address;
			}
			break;

		default:
			elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
				 (int) fc_stmt->objectType);
			return InvalidObjectAddress;	/* 保持编译器开心 */
	}
}

/*
 * 通用函数，用于更改给定对象的所有权，适用于简单
 * 情况（对表和其他需要做的不仅仅是更改单个目录条目
 * 的所有权列的情况无效）。
 *
 * rel: 包含对象的目录关系（由调用者 RowExclusiveLock）
 * objectId: 要更改所有权的对象的 OID
 * new_ownerId: 新对象所有者的 OID
 */
void AlterObjectOwner_internal(Relation fc_rel, Oid fc_objectId, Oid fc_new_ownerId)
{
	Oid			fc_classId = RelationGetRelid(fc_rel);
	AttrNumber	fc_Anum_oid = get_object_attnum_oid(fc_classId);
	AttrNumber	fc_Anum_owner = get_object_attnum_owner(fc_classId);
	AttrNumber	fc_Anum_namespace = get_object_attnum_namespace(fc_classId);
	AttrNumber	fc_Anum_acl = get_object_attnum_acl(fc_classId);
	AttrNumber	fc_Anum_name = get_object_attnum_name(fc_classId);
	HeapTuple	fc_oldtup;
	Datum		fc_datum;
	bool		fc_isnull;
	Oid			fc_old_ownerId;
	Oid			fc_namespaceId = InvalidOid;

	/* 搜索元组并锁定它。 */
	fc_oldtup =
		get_catalog_object_by_oid_extended(fc_rel, fc_Anum_oid, fc_objectId, true);
	if (fc_oldtup == NULL)
		elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
			 fc_objectId, RelationGetRelationName(fc_rel));

	fc_datum = heap_getattr(fc_oldtup, fc_Anum_owner,
						 RelationGetDescr(fc_rel), &fc_isnull);
	Assert(!fc_isnull);
	fc_old_ownerId = DatumGetObjectId(fc_datum);

	if (fc_Anum_namespace != InvalidAttrNumber)
	{
		fc_datum = heap_getattr(fc_oldtup, fc_Anum_namespace,
							 RelationGetDescr(fc_rel), &fc_isnull);
		Assert(!fc_isnull);
		fc_namespaceId = DatumGetObjectId(fc_datum);
	}

	if (fc_old_ownerId != fc_new_ownerId)
	{
		AttrNumber	fc_nattrs;
		HeapTuple	fc_newtup;
		Datum	   *fc_values;
		bool	   *fc_nulls;
		bool	   *fc_replaces;

		/* 超级用户可以绕过权限检查 */
		if (!superuser())
		{
			/* 必须是所有者 */
			if (!has_privs_of_role(GetUserId(), fc_old_ownerId))
			{
				char	   *fc_objname;
				char		fc_namebuf[NAMEDATALEN];

				if (fc_Anum_name != InvalidAttrNumber)
				{
					fc_datum = heap_getattr(fc_oldtup, fc_Anum_name,
										 RelationGetDescr(fc_rel), &fc_isnull);
					Assert(!fc_isnull);
					fc_objname = NameStr(*DatumGetName(fc_datum));
				}
				else
				{
					snprintf(fc_namebuf, sizeof(fc_namebuf), "%u", fc_objectId);
					fc_objname = fc_namebuf;
				}
				aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(fc_classId, fc_objectId),
							   fc_objname);
			}
			/* 必须能够成为新所有者 */
			check_is_member_of_role(GetUserId(), fc_new_ownerId);

			/* 新所有者必须对命名空间具有创建权限 */
			if (OidIsValid(fc_namespaceId))
			{
				AclResult	fc_aclresult;

				fc_aclresult = pg_namespace_aclcheck(fc_namespaceId, fc_new_ownerId,
												  ACL_CREATE);
				if (fc_aclresult != ACLCHECK_OK)
					aclcheck_error(fc_aclresult, OBJECT_SCHEMA,
								   get_namespace_name(fc_namespaceId));
			}
		}

		/* 构建修改后的元组 */
		fc_nattrs = RelationGetNumberOfAttributes(fc_rel);
		fc_values = palloc0(fc_nattrs * sizeof(Datum));
		fc_nulls = palloc0(fc_nattrs * sizeof(bool));
		fc_replaces = palloc0(fc_nattrs * sizeof(bool));
		fc_values[fc_Anum_owner - 1] = ObjectIdGetDatum(fc_new_ownerId);
		fc_replaces[fc_Anum_owner - 1] = true;

		/*
		 * 确定新所有者的修改后 ACL。这仅在 ACL 非空时必要。
		 */
		if (fc_Anum_acl != InvalidAttrNumber)
		{
			fc_datum = heap_getattr(fc_oldtup,
								 fc_Anum_acl, RelationGetDescr(fc_rel), &fc_isnull);
			if (!fc_isnull)
			{
				Acl		   *fc_newAcl;

				fc_newAcl = aclnewowner(DatumGetAclP(fc_datum),
									 fc_old_ownerId, fc_new_ownerId);
				fc_values[fc_Anum_acl - 1] = PointerGetDatum(fc_newAcl);
				fc_replaces[fc_Anum_acl - 1] = true;
			}
		}

		fc_newtup = heap_modify_tuple(fc_oldtup, RelationGetDescr(fc_rel),
								   fc_values, fc_nulls, fc_replaces);

		/* 执行实际更新 */
		CatalogTupleUpdate(fc_rel, &fc_newtup->t_self, fc_newtup);

		UnlockTuple(fc_rel, &fc_oldtup->t_self, InplaceUpdateTupleLock);

		/*
		 * 更新拥有者依赖引用。当处理一个大型对象时，
		 * 我们必须转换回传统上用于大对象的 OID 类别 ID。
		 */
		if (fc_classId == LargeObjectMetadataRelationId)
			fc_classId = LargeObjectRelationId;

		changeDependencyOnOwner(fc_classId, fc_objectId, fc_new_ownerId);

		/* 释放内存 */
		pfree(fc_values);
		pfree(fc_nulls);
		pfree(fc_replaces);
	}
	else
	{
		UnlockTuple(fc_rel, &fc_oldtup->t_self, InplaceUpdateTupleLock);

		/*
		 * 无需更改任何内容。但当处理一个大型对象时，我们
		 * 必须转换回传统上用于大对象的 OID 类别 ID，否则后续的修改钩子（如果有的话）会感到困惑。
		 */
		if (fc_classId == LargeObjectMetadataRelationId)
			fc_classId = LargeObjectRelationId;
	}

	InvokeObjectPostAlterHook(fc_classId, fc_objectId, 0);
}
